// ==UserScript==
// @name         ZJ名师网编辑器增强工具
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  增强ms.zjer.cn网站的UEditor编辑器功能：a. WORD复制的表格强制宽度、显示边框；b.标题样式强制修改。【已知问题】：图片粘贴时无法上传，图片上传功能未完善。
// @author       zjlester
// @match        https://ms.zjer.cn/*
// @grant        none
// @run-at       document-end
// ==/UserScript==


(function() {
    'use strict';

    // 等待UEditor加载完成
    function waitForEditorLoaded() {
        return new Promise(resolve => {
            const checkEditor = setInterval(() => {
                // 检查编辑器实例是否存在
                if (window.UE && UE.instants && Object.keys(UE.instants).length > 0) {
                    clearInterval(checkEditor);
                    // 获取第一个编辑器实例
                    const editorId = Object.keys(UE.instants)[0];
                    const editor = UE.instants[editorId];
                    resolve(editor);
                }
            }, 300);
        });
    }

    // 处理粘贴的内容格式
    function processPastedContent(html) {
        // 创建临时DOM处理粘贴的内容
        const tempDiv = document.createElement('div');
        tempDiv.innerHTML = html;

        // 处理标题格式
        processHeadings(tempDiv);

        // 处理表格格式
        processTables(tempDiv);

        // 返回处理后的HTML
        return tempDiv.innerHTML;
    }

    // 处理标题格式
    function processHeadings(container) {
        // 处理所有标题标签
        const headings = container.querySelectorAll('h1, h2, h3, h4, h5, h6');
        headings.forEach(heading => {
            heading.style.fontFamily = 'SimHei,黑体';
            heading.style.fontWeight = 'bold';
            heading.style.color = '#000000';
            heading.style.textAlign = 'left';
        });
    }

    // 处理表格格式
    function processTables(container) {
        const tables = container.querySelectorAll('table');
        tables.forEach(table => {
            // 设置表格样式
            table.style.margin = '0 auto'; // 居中显示
            table.style.width = '95%';
            table.style.borderCollapse = 'collapse';

            // 设置表格边框
            table.style.border = '1px solid #000';

            // 设置所有单元格边框
            const cells = table.querySelectorAll('th, td');
            cells.forEach(cell => {
                cell.style.border = '1px solid #000';
                cell.style.padding = '5px';
            });
        });
    }

    // 判断内容是否仅包含图片
    function isOnlyImages(html) {
        const tempDiv = document.createElement('div');
        tempDiv.innerHTML = html;

        // 移除所有图片元素
        const images = tempDiv.querySelectorAll('img');
        images.forEach(img => img.remove());

        // 检查剩余内容是否为空（忽略空白字符）
        const remainingContent = tempDiv.textContent.trim();
        return remainingContent === '' && images.length > 0;
    }

    // 拦截表单提交并处理内容
    function interceptFormSubmission(editor) {
        const submitBtn = document.getElementById('submit');
        if (submitBtn) {
            submitBtn.addEventListener('click', async function(e) {
                // 防止多次触发
                if (e.defaultPrevented) return;
                e.preventDefault();

                // 获取表单 - 使用更可靠的方式查找表单
                let form = submitBtn.closest('form');

                // 如果找不到表单，尝试通过其他方式获取
                if (!form) {
                    // 查找包含name为content的textarea的表单
                    const contentField = document.querySelector('textarea[name="content"]');
                    if (contentField) {
                        form = contentField.closest('form');
                    }
                }

                // 如果仍然找不到表单，使用最原始的方式提交
                if (!form) {
                    console.warn('未找到表单，尝试直接提交数据');
                    submitFormData(editor);
                    return;
                }

                try {
                    // 验证form元素确实是表单
                    if (!(form instanceof HTMLFormElement)) {
                        throw new Error('找到的元素不是表单');
                    }

                    // 获取编辑器内容并进行最终处理
                    let content = editor.getContent();
                    content = processPastedContent(content); // 再次处理确保格式正确

                    // 更新表单中的content字段
                    let contentField = form.querySelector('textarea[name="content"]');
                    if (contentField) {
                        contentField.value = content;
                    } else {
                        // 如果找不到textarea，创建一个隐藏字段
                        contentField = document.createElement('input');
                        contentField.type = 'hidden';
                        contentField.name = 'content';
                        contentField.value = content;
                        form.appendChild(contentField);
                    }

                    // 使用requestSubmit()方法提交，更可靠
                    if (form.requestSubmit) {
                        form.requestSubmit(submitBtn);
                    } else {
                        // 兼容旧浏览器的提交方式
                        form.dispatchEvent(new Event('submit', {cancelable: true}));
                    }
                } catch (error) {
                    console.error('提交表单时出错:', error);
                    // 出错时使用备用提交方式
                    submitFormData(editor);
                }
            });
        }
    }

    // 备用的表单提交方式，直接构建FormData并提交
    function submitFormData(editor) {
        try {
            // 获取编辑器内容
            let content = editor.getContent();
            content = processPastedContent(content);

            // 创建FormData
            const formData = new FormData();

            // 添加编辑器内容
            formData.append('content', content);

            // 收集页面上的其他表单字段
            const formFields = document.querySelectorAll('input, select, textarea');
            formFields.forEach(field => {
                // 跳过content字段，我们已经单独处理
                if (field.name && field.name !== 'content') {
                    // 处理复选框和单选按钮
                    if ((field.type === 'checkbox' || field.type === 'radio') && !field.checked) {
                        return;
                    }
                    formData.append(field.name, field.value);
                }
            });

            // 获取表单提交URL（从原网页信息中获取）
            const actionUrl = 'https://ms.zjer.cn/index.php?r=studio/admin/creataffiche';

            // 创建并发送请求
            const xhr = new XMLHttpRequest();
            xhr.open('POST', actionUrl, true);

            // 监听请求完成
            xhr.onload = function() {
                if (xhr.status >= 200 && xhr.status < 300) {
                    // 提交成功，模拟原页面跳转
                    window.location.reload();
                    // 或者根据实际情况跳转到成功页面
                } else {
                    alert('提交失败，状态码: ' + xhr.status);
                }
            };

            xhr.onerror = function() {
                alert('提交请求发生错误');
            };

            xhr.send(formData);
        } catch (error) {
            console.error('备用提交方式出错:', error);
            alert('提交失败: ' + error.message);
        }
    }

    // 初始化函数
    async function init() {
        console.log('UEditor增强工具开始初始化...');
        const editor = await waitForEditorLoaded();
        console.log('UEditor编辑器已加载，开始增强功能');

        // 获取编辑器的文档对象
        const editorDoc = editor.document;

        // 监听粘贴事件
        editorDoc.addEventListener('paste', async function(e) {
            e.preventDefault(); // 阻止默认粘贴

            // 获取剪贴板数据
            const clipboardData = e.clipboardData || window.clipboardData;
            const html = clipboardData.getData('text/html');
            const text = clipboardData.getData('text');

            if (!html && text) {
                // 如果只有纯文本，直接粘贴
                editor.execCommand('insertHtml', `<p>${text}</p>`);
                // 粘贴后立即处理样式
                setTimeout(() => processEditorContent(editor, true), 100);
                return;
            }

            if (html) {
                // 处理粘贴的HTML内容（文本和表格格式）
                let processedHtml = processPastedContent(html);
                editor.execCommand('insertHtml', processedHtml);
                // 粘贴后立即处理样式，强制处理而不检查焦点
                setTimeout(() => processEditorContent(editor, true), 100);
            }
        });

        // 设置表单提交拦截
        interceptFormSubmission(editor);

        // 启动内容变化监听器
        startContentObserver(editor);

        console.log('UEditor增强功能初始化完成');
    }

    // 处理编辑器内容，实时应用样式
    function processEditorContent(editor, forceProcess = false) {
        try {
            // 检查是否强制处理，如果不是强制处理则检查编辑器是否正在聚焦
            if (!forceProcess) {
                // 检查编辑器是否正在聚焦，避免在用户编辑时干扰
                const iframe = editor.container.querySelector('iframe');
                if (iframe && iframe.contentDocument && iframe.contentDocument.hasFocus()) {
                    // 编辑器正在被使用，延迟处理
                    setTimeout(() => processEditorContent(editor, false), 500);
                    return;
                }
            }

            const content = editor.getContent();
            const tempDiv = document.createElement('div');
            tempDiv.innerHTML = content;

            // 处理表格
            processTables(tempDiv);

            // 处理标题样式
            processHeadings(tempDiv);

            // 如果内容有变化，则更新编辑器
            if (tempDiv.innerHTML !== content) {
                editor.setContent(tempDiv.innerHTML);
            }
        } catch (error) {
            console.error('处理编辑器内容时出错:', error);
        }
    }

    // 启动内容观察器，监听编辑器内容变化
    function startContentObserver(editor) {
        try {
            // 获取编辑器iframe文档
            const iframe = editor.container.querySelector('iframe');
            if (!iframe || !iframe.contentDocument) {
                console.warn('无法获取编辑器iframe文档');
                return;
            }

            const doc = iframe.contentDocument;
            const body = doc.body;

            if (!body) {
                console.warn('无法获取编辑器body元素');
                return;
            }

            // 创建MutationObserver监听内容变化
            const observer = new MutationObserver(function(mutations) {
                let shouldProcess = false;

                // 检查是否有我们关心的元素变化
                for (let mutation of mutations) {
                    if (mutation.type === 'childList') {
                        // 检查新增节点
                        for (let node of mutation.addedNodes) {
                            if (node.nodeType === 1) { // 元素节点
                                if (isRelevantElement(node)) {
                                    shouldProcess = true;
                                    break;
                                }
                            }
                        }

                        if (shouldProcess) break;

                        // 检查移除节点
                        for (let node of mutation.removedNodes) {
                            if (node.nodeType === 1) { // 元素节点
                                if (isRelevantElement(node)) {
                                    shouldProcess = true;
                                    break;
                                }
                            }
                        }
                    } else if (mutation.type === 'attributes') {
                        // 检查属性变化
                        if (mutation.target && isRelevantElement(mutation.target)) {
                            shouldProcess = true;
                        }
                    }

                    if (shouldProcess) break;
                }

                // 如果检测到相关变化，处理内容
                if (shouldProcess) {
                    // 延迟处理，避免过于频繁的更新和干扰用户操作
                    setTimeout(() => {
                        // 检查编辑器是否正在聚焦
                        if (!doc.hasFocus()) {
                            processEditorContent(editor, false);
                        } else {
                            // 如果正在编辑，等待更长时间再处理
                            setTimeout(() => processEditorContent(editor, false), 1000);
                        }
                    }, 300);
                }
            });

            // 配置观察选项
            const config = {
                childList: true,
                subtree: true,
                attributes: true,
                attributeFilter: ['style', 'class']
            };

            // 开始观察
            observer.observe(body, config);

            console.log('内容观察器已启动');
        } catch (error) {
            console.error('启动内容观察器时出错:', error);
        }
    }

    // 判断元素是否是我们关心的元素（需要处理样式的元素）
    function isRelevantElement(node) {
        if (!node || node.nodeType !== 1) return false;

        // 检查元素标签
        const relevantTags = ['TABLE', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'TD', 'TH', 'TR'];
        if (relevantTags.includes(node.tagName)) {
            return true;
        }

        // 检查子元素
        if (node.querySelectorAll) {
            const elements = node.querySelectorAll('table, h1, h2, h3, h4, h5, h6, td, th, tr');
            return elements.length > 0;
        }

        return false;
    }

    // 启动初始化
    init();
})();